#ifndef Thread__HPP__
#define Thread__HPP__
#include <pthread.h>
#include <string>
#include<functional>

//v1
namespace MyThreadModule
{
    /**
     * enum class 是C++11标准引入的一种枚举类
     * 1. enum class定义的枚举值被限定在枚举类型内部，需要通过枚举类型名来访问，避免了命名冲突。
     * 2. enum class不能隐式转换为整型，必须显式转换，增强了类型安全性
     * 3. enum class还可以定义底层类型，允许开发者指定枚举值存储时使用的具体类型
     */
    enum class STATUS
    {
        EXIST,
        RUNNING,
        STOP
    };
    
    using func_t = std::function<void(std::string name)>;
    static int count = 1;

    class MyThread
    {
        // 默认有一个this指针，所以定义为static，否则参数不匹配
        static void *routing(void *args)
        {
            MyThread* pt = static_cast<MyThread*>(args);
            pt->_status = STATUS::RUNNING;
            pt->_func(pt->name());
            return nullptr;
        }

    public:
        MyThread(func_t func)
            :_func(func)
            ,_status(STATUS::EXIST)
            ,_joinable(true)
        {
            _name = "Thread-" + std::to_string(count++);
        }
        ~MyThread()
        {
        }

        bool create()
        {
            if (_status != STATUS::RUNNING)
            {
                // 为了让函数能够访问类内成员，给它传递的参数为：this指针
                int n = pthread_create(&_tid, nullptr, routing, this);
                if (n != 0)
                    return false;
                return true;
            }
            return false;
        }

        bool cancel()
        {
            if(_status == STATUS::RUNNING)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                    return false;
                _status = STATUS::STOP;
                return true;
            }
            return false;
        }

        bool join()
        {
            if(_joinable)
            {
                int n = pthread_join(_tid,nullptr);
                if(n != 0)
                    return false;
                _status = STATUS::STOP;
                return true;
            }
            return false;
        }

        bool detach()
        {
            if(_joinable)
            {
                int n = pthread_detach(_tid);
                if(n != 0)
                    return false;
                _joinable = false;
                return true;
            }
            return false;
        }

        std::string name()
        {
            return _name;
        }

    private:
        pthread_t _tid;
        std::string _name;
        STATUS _status;
        func_t _func; //是否可分离，默认是
        bool _joinable;
    };
}

//v2
// namespace MyThreadModule
// {
//     enum class STATUS
//     {
//         EXIST,
//         RUNNING,
//         STOP
//     };
//     static int count = 1;

//     template<class T>
//     class MyThread
//     {
//         using func_t = std::function<void(T&)>;

//         // 默认有一个this指针，所以定义为static，否则参数不匹配
//         static void *routing(void *args)
//         {
//             MyThread* pt = static_cast<MyThread*>(args);
//             pt->_status = STATUS::RUNNING;
//             pt->_func(pt->_data);
//             return nullptr;
//         }

//     public:
//         // MyThread() = default;
//         MyThread(func_t func,T& data)
//             :_func(func)
//             ,_status(STATUS::EXIST)
//             ,_joinable(true)
//             ,_data(data)
//         {
//             _name = "Thread-" + std::to_string(count++);
//         }

//         ~MyThread()
//         {
//         }

//         bool create()
//         {
//             if (_status != STATUS::RUNNING)
//             {
//                 // 为了让函数能够访问类内成员，给它传递的参数为：this指针
//                 int n = pthread_create(&_tid, nullptr, routing, this);
//                 if (n != 0)
//                     return false;
//                 // _status = STATUS::EXIST;
//                 return true;
//             }
//             std::cout << "创建失败" << std::endl;
//             return false;
//         }

//         bool cancel()
//         {
//             if(_status == STATUS::RUNNING)
//             {
//                 int n = pthread_cancel(_tid);
//                 if(n != 0)
//                     return false;
//                 _status = STATUS::STOP;
//                 return true;
//             }
//             std::cout << "取消失败" << std::endl;

//             return false;
//         }

//         bool join()
//         {
//             if(_joinable)
//             {
//                 int n = pthread_join(_tid,nullptr);
//                 if(n != 0)
//                     return false;
//                 _status = STATUS::STOP;
//                 return true;
//             }
//             std::cout << "等待失败" << std::endl;

//             return false;
//         }

//         bool detach()
//         {
//             if(_joinable)
//             {
//                 int n = pthread_detach(_tid);
//                 if(n != 0)
//                     return false;
//                 _joinable = false;
//                 return true;
//             }
//             return false;
//         }

//         std::string name()
//         {
//             return _name;
//         }

//     private:
//         pthread_t _tid;
//         std::string _name;
//         STATUS _status;
//         func_t _func; //是否可分离，默认是
//         bool _joinable;
//         T& _data;
//     };
// }



#endif